home *** CD-ROM | disk | FTP | other *** search
/ START Magazine / START VOL 4 NO 1.st / POGOSRC.ARC / FIXUP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-11-20  |  4.5 KB  |  251 lines
  1. /* fixup.c - Routines to help resolve forward references */
  2.  
  3. #include <stdio.h>
  4. #include "pogo.h"
  5.  
  6. /* Code to mark forward references in gotos */
  7. add_fref(op, sym)
  8. int op;
  9. Symbol *sym;
  10. {
  11. if (rframe->fref_count >= FREFS)
  12.     {
  13.     say_fatal("Too many forward references");
  14.     return;
  15.     }
  16. rframe->fref_ops[rframe->fref_count] = op;
  17. rframe->fref_sym[rframe->fref_count] = sym;
  18. rframe->fref_count++;
  19. }
  20.  
  21. /* Code to resolve forward references in gotos */
  22. fixup_fref()
  23. {
  24. int i;
  25. Symbol *s;
  26. struct pogo_op *code;
  27.  
  28. code = rframe->code_buf;
  29. for (i=0; i<rframe->fref_count; i++)
  30.     {
  31.     s = rframe->fref_sym[i];
  32.     if (s->type != LABEL)
  33.         {
  34.         printf("Undefined label %s\n", s->name);
  35.         fatal();
  36.         }
  37.     code[rframe->fref_ops[i]].data.i += s->symval.i;
  38.     }
  39. rframe->fref_count = 0;
  40. }
  41.  
  42. /* code to resolve forward references implied by break statements */
  43. bfixup(endoff)
  44. int endoff;
  45. {
  46. struct break_fixer *fixes;
  47. struct pogo_op *code;
  48.  
  49. fixes = bfix_frame->fixes;
  50. code = rframe->code_buf;
  51. while (fixes != NULL)
  52.     {
  53.     code[fixes->code_offset].data.i += endoff;
  54.     fixes = fixes->next;
  55.     }
  56. }
  57.  
  58. /* resolve all the forward function references in a given code body */
  59. resolve_some_funcs(ff, code)
  60. register struct func_forward *ff;
  61. struct pogo_op *code;
  62. {
  63. struct func_frame *fuf;
  64. Symbol *s;
  65.  
  66. while (ff != NULL)
  67.     {
  68.     s = ff->fsym;
  69.     if (s->type == FFUNC)
  70.         {
  71.         printf("%s %d function %s undefined\n", title, ff->source_line, 
  72.             s->name);
  73.         fatal();
  74.         break;
  75.         }
  76.     if (s->type == FCREATURE)
  77.         {
  78.         printf("%s %d creature %s undefined\n", title, ff->source_line, 
  79.             s->name);
  80.         fatal();
  81.         break;
  82.         }
  83. #ifdef OLD
  84.     if (s->type != CREATURE)
  85.         {
  86.         fuf = s->symval.p;
  87.         code[ff->code_offset].data.p = fuf->code;
  88.         }
  89. #endif OLD
  90.     ff = ff->next;
  91.     }
  92. }
  93.  
  94. /* resolve all the forward function references in a given code body */
  95. resolve_crw(cc, code)
  96. register struct crw_fixup *cc;
  97. struct pogo_op *code;
  98. {
  99. Symbol *s, *ls;
  100. struct func_frame *fuf;
  101.  
  102. while (cc != NULL)
  103.     {
  104.     s = cc->creature;
  105.     if (s->type != CREATURE)
  106.         {
  107.         printf("%s %d - creature %s undefined\n", title, cc->source_line, 
  108.             s->name);
  109.         fatal();
  110.         break;
  111.         }
  112.     fuf = s->symval.p;
  113.     if ((ls = in_list(fuf->symbols, cc->lvar)) == NULL)
  114.         {
  115.         printf("%s %d - %s isn't a local variable of creature %d\n",
  116.             title, cc->source_line, cc->lvar, s->name);
  117.         fatal();
  118.         break;
  119.         }
  120.     code[cc->code_offset].data.i = ls->doff;
  121.     cc = cc->next;
  122.     }
  123. }
  124.  
  125. /* add a forward creature local variable fixup */
  126. add_crw_fix(sym,lvar)
  127. Symbol *sym;
  128. char *lvar;
  129. {
  130. struct crw_fixup *ff;
  131.  
  132. if ((ff = beg_mem(sizeof(*ff))) == NULL)
  133.     return(0);
  134. if ((ff->lvar = clone_string(lvar)) == NULL)
  135.     {
  136.     freemem(ff);
  137.     return(0);
  138.     }
  139. ff->source_line = line_count;
  140. ff->creature = sym;
  141. ff->code_offset = rframe->op_count;
  142. ff->next = rframe->crw_fixes;
  143. rframe->crw_fixes = ff;
  144. return(1);
  145. }
  146.  
  147. free_crw(oc)
  148. struct crw_fixup *oc;
  149. {
  150. struct crw_fixup *c;
  151.  
  152. c = oc;
  153. while (c != NULL)
  154.     {
  155.     freemem(c->lvar);
  156.     c = c->next;
  157.     }
  158. free_list(oc);
  159. }
  160.  
  161.  
  162. /* resolve forward function references in code bodys of all functions,
  163.    creatures, and the main body */
  164. resolve_funcs()
  165. {
  166. struct func_frame *fuf;
  167.  
  168. fuf = ff_list;
  169. while (fuf != NULL)
  170.     {
  171.     resolve_some_funcs(fuf->ffixes, fuf->code+1);
  172.     free_list(fuf->ffixes);
  173.     fuf->ffixes = NULL;
  174.     resolve_crw(fuf->crw_fixes, fuf->code+1);
  175.     free_crw(fuf->crw_fixes);
  176.     fuf->crw_fixes = NULL;
  177.     fuf = fuf->next;
  178.     }
  179. }
  180.  
  181. #ifdef LATER
  182. /* make sure creatures all really defined */
  183. creatures_all_there()
  184. {
  185. register Symbol *s;
  186. int bad;
  187.  
  188. bad = 0;
  189. s = ff_list->symbols;
  190. while (s != NULL)
  191.     {
  192.     if (s->type == FCREATURE)
  193.         {
  194.         printf("Undefined creature %s\n", s->name);
  195.         bad = 1;
  196.         }
  197.     s = s->next;
  198.     }
  199. if (bad)
  200.     {
  201.     fatal();
  202.     wait_ok();
  203.     }
  204. }
  205. #endif LATER
  206.  
  207. /* count pogo instructions in all functions */
  208. count_is()
  209. {
  210. struct func_frame *fuf;
  211. int acc;
  212.  
  213. acc = 0;
  214. fuf = ff_list;
  215. while (fuf != NULL)
  216.     {
  217.     acc += fuf->code_size;
  218.     fuf = fuf->next;
  219.     }
  220. return(acc);
  221. }
  222.  
  223. add_bfixup()
  224. {
  225. register struct break_fixer *bfx1;
  226.  
  227. if ((bfx1 = (struct break_fixer *)beg_zero(sizeof(*bfx1))) == NULL)
  228.     return(0);
  229. bfx1->code_offset = rframe->op_count;
  230. bfx1->next = bfix_frame->fixes;
  231. bfix_frame->fixes = bfx1;
  232. return(1);
  233. }
  234.  
  235. /* add a forward function fixup */
  236. add_fff(sym)
  237. Symbol *sym;
  238. {
  239. struct func_forward *ff;
  240.  
  241. if ((ff = beg_mem(sizeof(*ff))) == NULL)
  242.     return(0);
  243. ff->source_line = line_count;
  244. ff->fsym = sym;
  245. ff->code_offset = rframe->op_count;
  246. ff->next = rframe->ffixes;
  247. rframe->ffixes = ff;
  248. return(1);
  249. }
  250.  
  251.